import java.util.ArrayList;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ListaCliente {

	private ArrayList<Cliente> lista;

	public ListaCliente() {
		/* TODO: inicialize as variaveis locais. */
	}

	public void add(Cliente cliente) {
		/* TODO: adicione a lista o cliente. */
	}

	public ArrayList<Cliente> search(int opt) {
		ArrayList<Cliente> myList = new ArrayList<Cliente>();

		Pattern pattern;
		Matcher matcher;
		String regex;

		/* TODO: Desenvolva a busca para cada opcao utilizando regex. */
		/* Utilize as funções Pattern.compile("regex"),
		 * pattern.matcher("String") e matcher.lookinAt(). */

		switch(opt){
		
		case 0:/*DONE*/
			/*
			 * Pessoas cujos primeiros cinco dígitos do telefone são todos primos;
			 */
			/*	Considera válido o DD: ^[1-9][0-9]\\s
			 * 	busca a ocorrência dos primeiros 5 dígitos do telefone todos primos: [2357]{4}-[2357]
			 */
			regex = "^[1-9][0-9]\\s[2357]{4}-[2357]";

			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				matcher = pattern.matcher(index.toString());
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}

			return myList;
		case 1:/*TODO: regex*/
			/*
			 * Pessoas cujo primeiro nome possui cinco letras que formam um palíndromo;
			 */
			/* 1 Forma: Case insensitive*/
			regex = "[a-z]{5}|\5";//sem flag de insensibility case: logo vale sensitive case
			pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
			/* 2 Forma: Case insensitive*/
			//regex = "(?i)[a-z]{5}|\5";//flag de insensibility case ativada
			//pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				//habilitado a flag de insensibility case, não precisa de pré-processamento
				matcher = pattern.matcher(index.getNome());
				/* 3 Forma: Case insensitive*/
				//pré-processamento: converte tudo para minúsculo
				//matcher = pattern.matcher(index.getNome().toLowerCase());

				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}
			return myList;
			
		case 2:/*DONE*/
			/*
			 * Pessoas cujo sobrenome contém uma sequência de seis letras (primeira
			 * consoante), formadas pela intercalação de três consoantes e três vogais;
			 */
			/*Subtração do conjunto A-Z com os conjunto das vogais:[A-Z&&[^AEIOU]]*/
			/*Próximo caractere esta dentro do da possibilidade A ou E ou I ou O ou U: [AEIOU]
			 * Busca ocorrência do grupo 3 vezes (Grupo){3}
			 */
			regex = "([A-Z&&[^AEIOU]][AEIOU]){3}";
			pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE);
			for(Cliente index: lista){
				matcher = pattern.matcher(index.getSobrenome());
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}

			return myList;
			
		case 3:/*DONE*/
			/*
			 * Pessoas que moram em cidades cujo nome é formado por três palavras;
			 * ([A-Za-z]+\\s):representa uma palavra
			 * Buscamos 3 palavras, logo temos duas com o padrão palavra e espaço, sendo a última apenas uma palavra
			 */
			regex = "([A-Za-z]+\\s){2}[A-Za-z]++";

			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				matcher = pattern.matcher(index.getCidade());
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}
			return myList;
			
		case 4:/*DONE*/
			/*
			 * Pessoas que contém um hífen no sobrenome em qualquer posição;
			 * 
			 */
			String sobrenome;
		
			regex = "-";
			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				sobrenome = index.getSobrenome();
				matcher = pattern.matcher(sobrenome);
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}
			return myList;
		case 5:/*DONE*/
			/*
			 *	Pessoas cujo nome da cidade e nome do estado começam com a mesma letra;
			 */
			String cidade, estado, aux;
			regex = "(\\w)[\\w]*:\1";
			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				cidade = index.getCidade();
				estado = index.getEstado();
				aux = cidade + ":"+ estado;
				matcher = pattern.matcher(aux);
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}

			return myList;
		case 6:/*TODO*/
			/*
			 *	Pessoas cujos dois dígitos do DDD estão contidos (em qualquer ordem) nos
			 *	primeiros cinco dígitos do número de telefone (obs.: no caso dos dígitos do
			 *	DDD serem iguais, os dígitos devem aparecer pelo menos duas vezes nos
			 *	dígitos do telefone);
			 */
			regex = " ";

			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				matcher = pattern.matcher(index.toString());
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}
			return myList;			
		case 7:/*TODO*/
			/*
			 *	Pessoas que possuem pelo menos duas vogais no nome e as mesmas duas
			 *	vogais no sobrenome.
			 */
			regex = " ";

			pattern = Pattern.compile(regex);
			for(Cliente index: lista){
				matcher = pattern.matcher(index.toString());
				boolean matches = matcher.matches();
				if(matches) myList.add(index);
			}

			return myList;
				default: return myList;
		}//fim do case

	}//fim do método search
}//fim da classe ListaCliente
